/**
 * 用户认证状态管理
 * 
 * 功能说明：
 * - 管理用户登录状态
 * - 处理用户信息存储
 * - 提供登录、注册、注销功能
 * - 自动处理token续期
 * 
 * 使用Zustand进行状态管理：
 * - 轻量级状态管理库
 * - 无需Provider包装
 * - 支持中间件扩展
 */

import { create } from 'zustand'
import { persist, devtools } from 'zustand/middleware'
import { message } from 'antd'
import authService from '@services/auth'

/**
 * 认证状态store定义
 */
const useAuthStore = create()(
  devtools(
    persist(
      (set, get) => ({
        // ==================== 状态字段 ====================
        
        /**
         * 用户信息
         * 包含用户基本信息、校区信息、信誉等级等
         */
        user: null,
        
        /**
         * 访问token
         * 用于API请求认证
         */
        token: null,
        
        /**
         * 刷新token
         * 用于自动续期访问token
         */
        refreshToken: null,
        
        /**
         * 认证状态
         * - true: 已登录
         * - false: 未登录
         */
        isAuthenticated: false,
        
        /**
         * 加载状态
         * - true: 正在加载（登录、注册、验证等）
         * - false: 空闲状态
         */
        isLoading: false,

        // ==================== 基础操作 ====================

        /**
         * 设置用户信息和token
         * 
         * @param {Object} userData - 用户数据
         * @param {string} userData.user - 用户信息
         * @param {string} userData.token - 访问token (扁平结构)
         * @param {string} userData.access_token - 访问token (后端统一返回)
         * @param {string} userData.refreshToken - 刷新token (扁平结构)
         * @param {string} userData.refresh_token - 刷新token (后端统一返回)
         */
        setAuth: (userData) => {
          // 统一token提取逻辑：后端统一返回扁平结构 {access_token, refresh_token}
          const token = userData.token || userData.access_token;
          const refreshToken = userData.refreshToken || userData.refresh_token;
          
          console.log('🔑 设置认证状态:', { 
            user: userData.user?.username, 
            hasToken: !!token, 
            hasRefreshToken: !!refreshToken,
            dataKeys: Object.keys(userData),
            rawData: userData
          });
          
          set({
            user: userData.user,
            token,
            refreshToken,
            isAuthenticated: true,
            isLoading: false
          })
          
          if (token) {
            authService.setAuthHeader(token)
          }
          // 强制写入localStorage，确保token不会丢失
          window.localStorage.setItem('auth-storage', JSON.stringify({
            state: {
              user: userData.user,
              token,
              refreshToken,
              isAuthenticated: true
            },
            version: 0
          }));
          
          console.log('✅ 用户认证状态已设置:', userData.user?.username)
        },

        /**
         * 清除认证状态
         * 用于注销登录
         */
        clearAuth: () => {
          set({
            user: null,
            token: null,
            refreshToken: null,
            isAuthenticated: false,
            isLoading: false
          })
          
          // 清除axios请求头
          authService.clearAuthHeader()
          
          console.log('🚪 用户认证状态已清除')
        },

        /**
         * 设置加载状态
         * 
         * @param {boolean} loading - 加载状态
         */
        setLoading: (loading) => {
          set({ isLoading: loading })
        },

        // ==================== 认证操作 ====================

        /**
         * 用户登录
         * 
         * @param {Object} credentials - 登录凭据
         * @param {string} credentials.email - 邮箱或用户名
         * @param {string} credentials.password - 密码
         * @returns {Promise<boolean>} 登录是否成功
         */
        login: async (credentials) => {
          try {
            set({ isLoading: true })
            console.log('🔑 尝试登录:', credentials)
            
            const response = await authService.login(credentials)
            console.log('🔐 登录响应:', response)
            
            // 登录成功后清除所有 recommend_shown_* 标记
            Object.keys(sessionStorage).forEach(key => {
              if (key.startsWith('recommend_shown_')) {
                sessionStorage.removeItem(key);
              }
            });
            
            // 判断登录是否成功 - 后端统一返回扁平结构
            if (response.access_token) {
              // 设置认证token
              authService.setAuthHeader(response.access_token)
              
              // 获取用户信息
              console.log('🔍 获取用户信息...')
              const userInfo = await authService.getCurrentUser()
              console.log('👤 用户信息:', userInfo)
              
              const authData = {
                user: userInfo,
                access_token: response.access_token,
                refresh_token: response.refresh_token
              }
              
              get().setAuth(authData)
              message.success('登录成功！')
              return authData
            }
            
            console.error('❌ 登录失败: 没有返回有效令牌')
            message.error(response.message || '登录失败')
            return false
          } catch (error) {
            console.error('❌ 登录错误:', error)
            message.error(error.response?.data?.message || '登录失败，请稍后重试')
            return false
          } finally {
            set({ isLoading: false })
          }
        },

        /**
         * 用户注册
         * 
         * @param {Object} userData - 注册数据
         * @param {string} userData.username - 用户名
         * @param {string} userData.email - 邮箱
         * @param {string} userData.password - 密码
      
         * @returns {Promise<boolean>} 注册是否成功
         */
        register: async (userData) => {
          try {
            set({ isLoading: true })
            
            const response = await authService.register(userData)
            
            if (response.success) {
              message.success('注册成功！请验证邮箱后登录')
              return true
            } else {
              message.error(response.message || '注册失败')
              return false
            }
          } catch (error) {
            console.error('注册错误:', error)
            message.error(error.response?.data?.message || '注册失败，请稍后重试')
            return false
          } finally {
            set({ isLoading: false })
          }
        },

        /**
         * 用户注销
         */
        logout: async () => {
          try {
            // 调用后端注销API（可选）
            await authService.logout()
          } catch (error) {
            console.error('注销API调用失败:', error)
          } finally {
            // 无论API调用是否成功，都清除本地状态
            get().clearAuth()
            // 退出登录时清除所有 recommend_shown_* 标记
            Object.keys(sessionStorage).forEach(key => {
              if (key.startsWith('recommend_shown_')) {
                sessionStorage.removeItem(key);
              }
            });
            message.success('已退出登录')
          }
        },

        /**
         * 检查认证状态
         * 
         * 应用启动时调用，验证本地存储的token是否有效
         */
        checkAuth: async () => {
          const { token } = get()
          
          if (!token) {
            console.log('📝 本地未找到token，用户未登录')
            return
          }

          try {
            set({ isLoading: true })
            
            // 验证token有效性
            const response = await authService.verifyToken()
            
            // 后端统一返回结构，token验证成功时返回user信息
            if (response && response.user) {
              // token有效，更新用户信息
              set({
                user: response.user,
                isAuthenticated: true
              })
              
              // 设置axios请求头
              authService.setAuthHeader(token)
              
              console.log('✅ Token验证成功，用户已登录')
            } else {
              // token无效，清除认证状态
              console.log('❌ Token验证失败，清除认证状态')
              get().clearAuth()
            }
          } catch (error) {
            console.error('Token验证错误:', error)
            get().clearAuth()
          } finally {
            set({ isLoading: false })
          }
        },

        /**
         * 刷新访问token
         * 
         * 当访问token过期时自动调用
         * @returns {Promise<boolean>} 刷新是否成功
         */
        refreshAccessToken: async () => {
          const { refreshToken } = get()
          
          if (!refreshToken) {
            console.log('❌ 无刷新token，无法自动续期')
            get().clearAuth()
            return false
          }

          try {
            const response = await authService.refreshToken(refreshToken)
            
            // 后端统一返回扁平结构 {access_token, refresh_token}
            if (response.access_token) {
              // 更新token
              set({
                token: response.access_token,
                refreshToken: response.refresh_token || refreshToken
              })
              
              // 更新axios请求头
              authService.setAuthHeader(response.access_token)
              
              console.log('✅ Token刷新成功')
              return true
            } else {
              console.log('❌ Token刷新失败')
              get().clearAuth()
              return false
            }
          } catch (error) {
            console.error('Token刷新错误:', error)
            get().clearAuth()
            return false
          }
        },

        /**
         * 更新用户信息
         * 
         * @param {Object} userInfo - 新的用户信息
         */
        updateUser: (userInfo) => {
          set(state => ({
            user: { ...state.user, ...userInfo }
          }))
        }
      }),
      {
        // 持久化配置
        name: 'auth-storage', // localStorage key
        partialize: (state) => ({
          // 只持久化必要的字段
          user: state.user,
          token: state.token,
          refreshToken: state.refreshToken,
          isAuthenticated: state.isAuthenticated
        })
      }
    ),
    {
      // 开发工具配置
      name: 'auth-store'
    }
  )
)

export { useAuthStore } 

// 页面刷新后自动同步 token 到 axios
const { token } = useAuthStore.getState();
if (token) {
  authService.setAuthHeader(token);
} 